package array;

import java.util.Arrays;

public class TestDriver5 {

    public static void main(String[] args) {
        System.out.println("---------一维数组-----------------");
        test01();
        System.out.println();
        System.out.println("---------二维数组-----------------");
        test02();
        System.out.println();
        System.out.println("--(j< arr.length-1)数组冒泡排序--使用printArr方法打印数组元素---------------");
        test03();
        System.out.println();
        System.out.println("---(j< arr.length-1-i)数组冒泡排序--使用printArr方法打印数组元素---------------");
        test031();
        System.out.println();
        System.out.println("====设置标志位，记录是否发生交换，如果本轮没有发生交换，则说明数列已经有序===" +
                "=========数组冒泡排序==使用printArr方法打印数组元素======");
        test032();
        System.out.println();
        System.out.println("======数组Arrays工具类----sort方法----从小到大排序---printArr方法打印输出===");
        test04();
        System.out.println();
        System.out.println("==数组Arrays工具类--数组的扩容---" +
                "----int[] arrNew = Arrays.copyOf(arr,20);---printArr方法打印输出=====");
        test05();
        System.out.println();
        System.out.println("==数组Arrays工具类--数组的扩容---"+
                "int[] arr = new int[]{2,5,4,7,9};" +
                "int[] arrNew  = new int[20];" +
                "System.arraycopy(arr , 0 ,arrNew,0,arr.length);"+
                "----printArr方法打印输出=====");
        test06();
    }

    /**
     * 一维数组
     */
    public  static void test01(){
        //声明数组
        int[] arr;

        //arr = {12,53};//不能这样写初始化

        //不推荐
        int arr1[];

        //初始化一维数组
        int[] arr2 = new int[5];
        int[] arr3 = new int[]{1,2,8,7,6,4,3,2};
        int[] arr4 ={1,3,4,8,9,7,5,4,6};

        //初始化赋值
        for (int i = 0;i<arr3.length;i++){
            arr3[i] = i;

        }

        //数组越界i<=arr.length即不能等于
        //for-each;增强型的for，不会产生越界，但是也不知道当前遍历元素的下标
        for (int i:arr3) {
            System.out.println("  "+i);
        }
        System.out.println("-----------一维数组的遍历---------------");
        //一维数组的遍历
        for (int i = 0 ; i < arr3.length ; i++){
            System.out.println("   "+arr3[i]);
        }

    }

    /**
     * 二维数组
     */
    public  static  void test02(){
        //声明二维数组
        int[][] arr;
        //初始化
        int[][] arr1 = new  int[3][4];
        int[][] arr2 = new int[][]{{1,2,3,4},{7,8,9,4,3},{1,2,35,6}};
        int[][] arr3 = {{0,2,3,45,7},{15,48,56,42,15,2},{15,8,6,2,1,3}};
        //分开声明初始化
        int[][] arr4 = new int[3][];
        //第二步：每一步都要初始化
        arr4[0] = new int[4];
        arr4[1] = new int[3];
        arr4[2] = new int[4];

        //二维数组的遍历
        //外层for遍历行数
        for (int i = 0;i< arr2.length;i++){
           // System.out.println("--外层for遍历行数--");
            for (int j = 0;j< arr2[i].length;j++){
               // System.out.println("--内层for遍历行数--");
                //System.out.println("获取当前行的列数");
                System.out.println("  "+arr2[i][j]);
            }
            System.out.println();
        }

    }


    /**
     *  冒泡排序
     */
    public  static void test03(){
        //被排序的数组-----从小到大
        System.out.println("被排序的数组-----从小到大");
        //声明初始化数组
        int[] arr = new int[]{1,6,7,8,4,2,3};
        System.out.println("排序之前的数组："+arr);
        printArr(arr);
        //统计比较次数--优化
        int count  = 0;
        //冒泡排序算法思想
        //外层for循环控制轮数，最多arr.length轮
        for (int i = 0 ; i<arr.length ; i++){
            for (int j = 0 ; j<arr.length-1 ; j++){
                //j< arr2.length-i-1
                count++;
                if (arr[j]>arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
                }
            }
        }
        System.out.println("排序后的数组："+arr);
        printArr(arr);
        System.out.println("本次排序发生的比较次数："+count);

    }

    /**
     * 冒泡排序法第二种
     */
    public  static  void  test031(){
        //被排序的数组-----从小到大
        System.out.println("(j< arr.length-1-i)被排序的数组-----从小到大");
        //声明初始化数组
        int[] arr = new int[]{1,6,7,8,4,2,3};
        System.out.println("排序之前的数组："+arr);
        printArr(arr);
        //统计比较次数--优化
        int count  = 0;
        //冒泡排序算法思想
        //外层for循环控制轮数，最多arr.length轮
        for (int i = 0 ; i<arr.length ; i++){
            for (int j = 0 ;j< arr.length-1-i ; j++){
                //j< arr.length-1-i
                count++;
                if (arr[j]>arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        System.out.println("排序后的数组："+arr);
        printArr(arr);
        System.out.println("本次排序发生的比较次数："+count);
    }

    /**
     * 冒泡排序的交换
     */
    public  static  void test032(){

        //被排序的数组----从小到大
        //定义数组
        int[] arr = new int[]{1,5,7,8,45,61,2};
        System.out.println("排序之前的数组：");
        printArr(arr);

        int count = 0;
        //冒泡排序的算法思想
        //外层for循环控制轮数，最多以arr.length轮
        for (int i = 0 ; i<arr.length; i++){
            //设置一个标志位，记录是否发生交换，如果本轮没有发生交换，则说明数列已经有序
            boolean isChenged = false;//默认没有交换
           //内层for循环完成任务是两两比较，并按照比较结果进行交换
            for (int j = 0;j<arr.length-1-i;j++){
                //比较次数+1
                count++;
                //比较交换
                if (arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j] =arr[j+1];
                    arr[j+1] = temp;

                    //发生了交换，修改交换标志位
                    isChenged = true;
                }
            }
            //判断本轮是否发生交换，如果发生交换，说明数列有序，可以终止排序操作
            if (isChenged == false){
                break;
            }
        }
        System.out.println("排序后的数组：");
        printArr(arr);
        System.out.println("本次排序发生的比较次数：");


    }

    /**
     * 数组----Arrays工具类
     */

    public  static  void test04(){
        //定义数组----被排序的数组从小到大
        int[] arr = new int[]{3,5,56,48,1,21,58};
        System.out.println("排序之前的数组：" );
        //打印输出
        printArr(arr);
        Arrays.sort(arr);//sort在Arrays工具类中的从小到大排序
        System.out.println("排序后的数组：");
        printArr(arr);
    }

    /**
     * 数组---Arrays工具类---数组的扩容
     */
    public  static  void test05(){
        //定义数组
        //被扩容的数组
        int[] arr = new int[]{3,5,9,7,4,1,56,8};
        System.out.println("扩容之前的数组：");
        printArr(arr);
        //使用Arrays工具类进行扩容
        int[] arrNew = Arrays.copyOf(arr,15);
        System.out.println("扩容之后的数组：");
        printArr(arrNew);
        System.out.println("判断扩容前后是否是同一个存储单元"+(arr == arrNew));
        arr = arrNew;
    }

    /**
     * 数组---数组的扩容的第二种方法
     */

    public  static void test06(){
        //定义数组
        int[] arr = new int[]{2,5,4,7,9};
        System.out.println("被扩容之前的数组：");
        printArr(arr);
        //Arrays工具类扩容数组
        int[] arrNew  = new int[20];
        System.arraycopy(arr , 0 ,arrNew,0,arr.length);
        System.out.println("扩容之后的数组：");
        printArr(arrNew);
        System.out.println("判断是否是同一个存储单元："+(arr == arrNew));
        arr = arrNew;
    }


    /**
     * 遍历打印数组元素
     * @param arr
     * 被打印的数组
     */
    private static  void printArr(int[] arr){
        for (int i:arr) {
            System.out.println("  "+i);
        }
        System.out.println();
    }


}
